import java.io.*;
import java.util.*;

import javax.swing.JOptionPane;

/**
 * Classe controleur et application (système)
 * @author IUT,   A. Culet
 * @version 1.0 
 */

//public class Controleur extends Observable implements Serializable{
public class Controleur implements Serializable{
	
	private static final long serialVersionUID = 1L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est également la classe "application" qui gère l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
	
		// Attributs d'Association
		// Ensemble des ouvrages de la bibliothèque
		private HashMap<String, Ouvrage> _ouvrages; 
		private HashMap<String, Periodique> _periodiques; 
		private HashMap<String, Auteur> _auteurs;
		private HashSet<MotCle> _motcles;
		
		// les différentes fenêtres pour chaque fonctionnalité
		private VueMenuBiblio _vueMenuBiblio = null;
		
		// une seule fenêtre est active à la fois; les autres sont à null.
		// permet de connaître l'état des fenêtres de l'interface
		private VueSaisieOuvrage _vueSaisieOuvrage = null;
		private VueSaisieExemplaire _vueSaisieExemplaire = null;
		private VueConsultOuvrage _vueConsultOuvrage = null;
		private VueSaisiePeriodique _vueSaisiePeriodique = null;
		private VueSaisieParution _vueSaisieParution = null;
		private VueConsultPeriodique _vueConsultPeriodique = null;
		private VueRechercheAuteur _vueRechercheAuteur = null;
		private VueRechercheMotcle _vueRechercheMotcle = null;
		
		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			setOuvrages(new HashMap<String, Ouvrage>());
			setPeriodiques();
			this.setAuteurs(new HashMap<String, Auteur>());
		} // Fin Controleur

		// ************************************************************************************************************
		// Méthodes privées
		// ************************************************************************************************************

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		/**initialise les dictionnaires**/
		
			private void setAuteurs(HashMap<String, Auteur> auteurs){ _auteurs = auteurs; }
			private void setOuvrages(HashMap<String, Ouvrage> ouvrages) { _ouvrages = ouvrages; }
			private void setPeriodiques() { _periodiques = new HashMap<String, Periodique>(); }
			
			private void setMotcles() { 	
				String fichier ="ListeAutorite.txt"; //fichier texte a lire (a la racine du projet)				
				try{
					_motcles = new HashSet<MotCle>(); String ligne;
					
					BufferedReader f = new BufferedReader(new InputStreamReader(new FileInputStream(fichier)));
					while ((ligne=f.readLine())!=null) { _motcles.add(new MotCle(ligne)); } 
					f.close(); 
				}
				catch (Exception e) { System.out.println(e.toString()); } 
			}
			
		/**ajoute un objet a un dictionnaire**/
			
			private void setOuvrage(Ouvrage ouvrage, String isbn) { this.getOuvrages().put(isbn, ouvrage); }
			
			private void setPeriodique(Periodique pe, String issn) {
				if (_periodiques == null) { _periodiques = new HashMap<String, Periodique>(); }
				_periodiques.put(issn, pe);
			} 
			
			private void resetAuteur() {
				Iterator<String> it = _auteurs.keySet().iterator();
		        while(it.hasNext()) 
		        { 
		        	Auteur i = this.getAuteur(it.next()); 
		        	if (i.getDocuments().isEmpty() || i.getDocuments()==null) 
		        	{ 
		        		String key = i.getNom()+" "+i.getPrenom(); 
		        		_auteurs.remove(key); 
		        		it = _auteurs.keySet().iterator();
		        	}
		        }
			}

		/**initialise les vues**/
		
			private void setVueMenuBiblio(VueMenuBiblio vue) { _vueMenuBiblio = vue; }
			private void setVueSaisieOuvrage(VueSaisieOuvrage vue) { _vueSaisieOuvrage = vue; }
			private void setVueSaisieExemplaire(VueSaisieExemplaire vue) { _vueSaisieExemplaire = vue; }
			private void setVueConsultOuvrage(VueConsultOuvrage vue) { _vueConsultOuvrage = vue; }
			private void setVueSaisiePeriodique(VueSaisiePeriodique vue) { _vueSaisiePeriodique = vue; }
			private void setVueSaisieParution(VueSaisieParution vue) { _vueSaisieParution = vue; }
			private void setVueConsultPeriodique(VueConsultPeriodique vue) { _vueConsultPeriodique = vue; }
			private void setVueRechercheAuteur(VueRechercheAuteur vue) { _vueRechercheAuteur = vue; }
			private void setVueRechercheAuteur(VueRechercheMotcle vue) { _vueRechercheMotcle = vue; }
		
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		
		/**retourne les dictionnaires**/
		
			private HashMap<String, Ouvrage> getOuvrages() { return _ouvrages; }
			//private HashMap<String, Periodique> getPeriodiques() { return _periodiques; }
			private HashSet<MotCle> getMotcles() { return _motcles; }
		
		/**retourne un objet correspondant a une cle**/
		
		Ouvrage getOuvrage(String isbn) { return this.getOuvrages().get(isbn); } //retourne l'ouvrage correspondant à l'isbn

		Periodique getPeriodique(String issn) {
			if (_periodiques == null) { return null; } 
			else if (_periodiques.isEmpty()) { return null; } 
			else { return  _periodiques.get(issn); }
		} 
		
		MotCle getMotcle(String mot) {
			if (_motcles == null) { return null; } 
			else  { 
				for (MotCle m : _motcles) {
					if (m.getMot()==mot) return m;
				}
				
				return null; 
			}
		}
		
TreeSet<String> getMots(String mot) {
			
			TreeSet<String> selectMots = new TreeSet<String>();
			
			if ( mot != "" ) {
				for ( MotCle m : _motcles ) {
					if ( m.getMot().length() >= mot.length() ) {
						Boolean wordMatch = true;
						for ( int i = 0 ; i < mot.length() && wordMatch ; i++ ) {
							if ( mot.charAt(i) != m.getMot().charAt(i) ) {
								wordMatch = false;
							}
						}
						if ( wordMatch ) {
							selectMots.add(m.getMot());
						}
					}
				}
			} else {
					for ( MotCle m : _motcles ) {
						selectMots.add(m.getMot());
					}
			}
			return selectMots;
		}
		
		/**retourne les vues**/
		
			private VueMenuBiblio getVueMenuBiblio() { return _vueMenuBiblio ; }
			private VueSaisieOuvrage getVueSaisieOuvrage() { return _vueSaisieOuvrage ; }
			private VueSaisieExemplaire getVueSaisieExemplaire() { return _vueSaisieExemplaire ; }
			private VueConsultOuvrage getVueConsultOuvrage() { return _vueConsultOuvrage ; }
			private VueSaisieParution getVueSaisieParution() { return _vueSaisieParution ; }
			private VueSaisiePeriodique getVueSaisiePeriodique() { return _vueSaisiePeriodique ; }
			private VueConsultPeriodique getVueConsultPeriodique() { return _vueConsultPeriodique ; }
			private VueRechercheAuteur getVueRechercheAuteur() { return _vueRechercheAuteur ; }
			private VueRechercheMotcle getVueRechercheMotcle() { return _vueRechercheMotcle ; }
		
		// ************************************************************************************************************
		// Méthodes publiques de création et affichage des fenêtres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Création et affichage de la fenêtre principale de l'application. 
		 * Elle reste affichée
		 */
		
		public void menuBiblio() {
			try { this.setVueMenuBiblio(new VueMenuBiblio(this)); } 
			catch (Exception e) { e.printStackTrace(); }
		}
		/**
		 * Création et affichage de la fenêtre de consultation d'un ouvrage
		 */
		
		public void consulterOuvrage() {
			try {this.setVueConsultOuvrage (new VueConsultOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVueConsultOuvrage().setEtat(Vue.initiale);
				this.getVueConsultOuvrage().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
		 */
		public void saisirExemplaire() {
			try {this.setVueSaisieExemplaire(new VueSaisieExemplaire(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieExemplaire
				this.getVueSaisieExemplaire().setEtat(Vue.initiale);
				this.getVueSaisieExemplaire().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de saisie d'un ouvrage
		 */
		public void saisirOuvrage() {
			try {this.setVueSaisieOuvrage(new VueSaisieOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisieOuvrage().setEtat(Vue.initiale);
				this.getVueSaisieOuvrage().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		/**
		 * Création et affichage de la fenêtre de saisie d'une parution
		 */
		public void saisirParution() {
			try {this.setVueSaisieParution(new VueSaisieParution(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisieParution().setEtat(Vue.initiale);
				this.getVueSaisieParution().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void saisirPeriodique() {
			try {this.setVueSaisiePeriodique(new VueSaisiePeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisiePeriodique().setEtat(Vue.initiale);
				this.getVueSaisiePeriodique().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void consultPeriodique() {
			try {
				this.setVueConsultPeriodique(new VueConsultPeriodique(this));
				// le Menu est caché
				this.getVueMenuBiblio().getFrame().setVisible(false); 
				// la vue courante est VueSaisieOuvrage
					this.getVueConsultPeriodique().setEtat(Vue.initiale);
					this.getVueConsultPeriodique().setVisible(true);
			} 
			catch (Exception e) { e.printStackTrace(); }
		}
		
		public void rechercherAuteur() {
			try {
				if (_auteurs==null || _auteurs.isEmpty()) 
				{ 
					Message dialog = new Message("Aucun auteur n'est entré dans la Base de donné");
					dialog.setVisible(true);
				}
				else
				{
					this.setVueRechercheAuteur(new VueRechercheAuteur(this));
					// le Menu est caché
					this.getVueMenuBiblio().getFrame().setVisible(false); 
					// la vue courante est VueRechercheAuteur
					this.getVueRechercheAuteur().setVisible(true);
					this.getVueRechercheAuteur().alimente(_auteurs);
				}
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void rechercherMotcle() {
			try {this.setVueRechercheAuteur(new VueRechercheMotcle(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueRechercheMotcle
				this.getVueRechercheMotcle().setEtat(Vue.initiale);
				this.getVueRechercheMotcle().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		/**
		 * fermeture de la fenêtre vue
		 * lors de la fermeture de la fenêtre principale de l'application sauvegarde des objets sérialisés 
		 */
		public void fermerVue (Vue vue) {
			if (vue instanceof VueMenuBiblio ) {	
			// Quitte l'aplication. Sauvegarde les objets du modèle
				this.sauve();
				System.exit(0);
				}
			vue.dispose();
			// le Menu est rendu de nouveau visible
			this.getVueMenuBiblio().getFrame().setVisible(true);
			this.resetVues();
		}
		
		// Restaure l'état de l'interface avec seule la fenêtre du Menu principal active
		private void resetVues() {
			this.setVueSaisieOuvrage (null);
			this.setVueConsultOuvrage(null);
			this.setVueSaisieExemplaire(null);
		}
		
		// ************************************************************************************************************
		// Opérations liées à la sérialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.ser");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} catch (Exception e) {
				Message dialog = new Message("Pbs de Restauration ou fichier non encore créé");
				dialog.setVisible(true);
				this.setMotcles();
				return this;
			} 
		}
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.ser");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} catch (Exception e) {
				Message dialog = new Message("Pb de Sauvegarde dans le fichier");
				dialog.setVisible(true);
			}
		}
		// ************************************************************************************************************
		// Opérations liées à l'application en réponse à une action de l'utilisateur dans une vue
		// ************************************************************************************************************
		
		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * Invoqué dans VueConsultOuvrage et VueSaisieExemplaire
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué ou null
		 * affiche un message d'erreur si l'ouvrage n'est pas trouvé
		 */
		public Ouvrage rechOuvrage(String isbn) {
			Ouvrage ouv = this.getOuvrage(isbn);
			if (ouv == null) {
				Message dialog = new Message("Ouvrage inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueSaisieExemplaire() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					ouv.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
					this.getVueSaisieExemplaire().setEtat(Vue.inter1);
					this.getVueSaisieExemplaire().alimente(ouv);
					}
				// la vue courante est VueConsultOuvrage
				if (this.getVueConsultOuvrage() != null) {
					// le contrôleur modifie l'état de la vue
					this.getVueConsultOuvrage().setEtat(Vue.finale);
					this.getVueConsultOuvrage().alimente(ouv);
					}
			}
			return ouv;
		} // Fin rechOuvrage
		
		/**
		 * Création d'un exemplaire d'ouvrage 
		 * Invoqué dans VueSaisieExemplaire
		 * @param ouv l'ouvrage  dateRecep la date de réception de l'exemplaire	
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
			// vérification de la présence de la date et de son format
			if (dateReception.length() == 0 ){
					Message dialog = new Message("La date de réception est obligatoire");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateReception);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				else {
					int statutEx;
					if (statut == "empruntable") {
						statutEx = Exemplaire.EMPRUNTABLE ; }
					else {
						statutEx = Exemplaire.EN_CONSULTATION ; }
			// demande d'ajout de l'exemplaire
					Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
			// l'opération s'est bien passée
					if (exemplaire != null) {
			// le contrôleur modifie l'état de la vue
						this.getVueSaisieExemplaire().setEtat(Vue.finale);
			// affichage d'un message de confirmation
						Message dialog = new Message("Exemplaire enregistré");
						dialog.setVisible(true);
					}
					else {
						Message dialog = new Message("Date de Reception incorrecte / à la date d'Edition.");
						dialog.setVisible(true);
					}
				}
			}
		} // Fin nouvExemplaire
		
		/**
		 * Création d'un  d'ouvrage 
		 * Invoqué dans VueSaisieOuvrage
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvOuvrage(String isbn, String titre, String editeur, String dateEdition) {
			// vérification de la présence des infos obligatoires et du format de la date
			if ((isbn.length() == 0) || (titre.length() == 0)
					|| (editeur.length() == 0 )|| (dateEdition.length() == 0 )){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateEdition);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				else if (this.getOuvrage(isbn )== null) {
				// Instanciation de l'ouvrage
					Ouvrage ouvrage = new Ouvrage(isbn, titre, editeur, date);
				// Ajout de l'ouvrage dans l'ensemble des ouvrages de la bibliothèque
					this.setOuvrage(ouvrage, isbn);
					Message dialog = new Message("Ouvrage enregistré");
					dialog.setVisible(true);
					getVueSaisieOuvrage().alimente(this.getMotcles());
					this.getVueSaisieOuvrage().setEtat(Vue.inter1);
					} 
					else {
						Message dialog = new Message("Ouvrage déjà présent");
						dialog.setVisible(true);
					}
				}
			}
		
		public void nouvPeriodique(String issn, String nom) {
			if ((issn.length() == 0) || (nom.length() == 0)){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
			} else {
				if (this.getPeriodique(issn)== null) {
					Periodique per = new Periodique(issn, nom);
					setPeriodique(per, issn);
					
					Message dialog = new Message("Périodique enregistré");
					dialog.setVisible(true);
					this.fermerVue (this.getVueSaisiePeriodique());
				} else {
						Message dialog = new Message("Ce périodique existe déjà");
						dialog.setVisible(true);
				}
			}
		}

/*recherche*/
		public void rechDocsAuteur(String val) {
			Auteur a = this.getAuteur(val);
			HashSet<Document> docs = a.getDocuments();
			
			this.getVueRechercheAuteur().setAuteur(a);
			this.getVueRechercheAuteur().setEtat(Vue.finale);
			this.getVueRechercheAuteur().alimente(docs);
		}
		
/*parutions*/
		public Periodique rechPeriodique(String issn) {
			Periodique pe = getPeriodique(issn);
			//on verifie que le periodique demande existe
			if (pe==null)
			{
				Message dialog = new Message("Ce périodique n'existe pas");
				dialog.setVisible(true);
			}
			else
			{
				if (this.getVueSaisieParution() != null) {
					pe.addObserver(this.getVueSaisieParution());
					this.getVueSaisieParution().setEtat(Vue.inter1);
					this.getVueSaisieParution().alimente(pe);
				}
				if (this.getVueConsultPeriodique() != null) {
					pe.addObserver(this.getVueConsultPeriodique());
					this.getVueConsultPeriodique().setEtat(Vue.finale);
					this.getVueConsultPeriodique().alimente(pe);
				}
			}	
			return pe;
		}

		public void nouvParution(Parution parution) {		
			Message dialog = new Message("La parution a bien été enregistrée");
			dialog.setVisible(true);
			this.fermerVue(this.getVueSaisieParution());
		}
		
		public Parution nouvParution(Periodique periodique, String nom) {
		Parution parution = null;
		if (nom.length() == 0 ){
				Message dialog = new Message("Le nom est obligatoire");
				dialog.setVisible(true);
		}
		else {
			//on verifie que cette parution n'existe pas deja
			if (periodique.getParution(nom)== null) {				
				parution = new Parution(nom, periodique);			
				periodique.ajouterParution(parution);
				this.getVueSaisieParution().setEtat(Vue.inter2);
				this.getVueSaisieParution().alimente(periodique);
				this.getVueSaisieParution().alimente(this.getMotcles());
			} 
			else {
				Message dialog = new Message("Cette parution existe déjà !");
				dialog.setVisible(true);
			}
		}
		return parution;
		} 
		
		public void nouvAuteur(String nom, String prenom, Article article) {
			if (nom.isEmpty() || prenom.isEmpty()){
				Message dialog = new Message("Le nom et le prenom de l'auteur ne peuvent pas être vides");
				dialog.setVisible(true);
			}
			else
			{
				Auteur a = this.rechAuteur(nom, prenom);
				if (a == null){ a = new Auteur(nom, prenom); this.setAuteur(a); }
				
				String key = a.getNom()+" "+a.getPrenom();
				if (article.getAuteurs().containsKey(key)){
					Message dialog1 = new Message("L'auteur <" + a.getNom()+ " " + a.getPrenom() + "> a DEJA été ajouté !!");
					dialog1.setVisible(true);
				}
				else{
					this.ajouterArticleAuteur(article, a);
					Message dialog = new Message("L'auteur <" + a.getNom()+ " " + a.getPrenom() + "> a été ajouté");
					dialog.setVisible(true);
				}
				this.getVueSaisieParution().setEtat(Vue.inter3);
			}
		}
		
		public void nouvMotcle(String mot, Article article) {
			MotCle m = getMotcle(mot);

			if (article.getMotCles().contains(m)){
				Message dialog = new Message("Le mot-cle <" + mot + "> DEJA a été ajouté !!"); 
				dialog.setVisible(true);
			}
			else{
				article.ajouterMotCle(m);
				Message dialog = new Message("Le mot-cle <" + mot + "> a été ajouté"); 
				dialog.setVisible(true);
				this.getVueSaisieParution().setEtat(Vue.inter4);
			}
		}
		
		public void nouvMotcle(String mot, Ouvrage ouvrage) {
			MotCle m = getMotcle(mot);

			if (ouvrage.getMotCles().contains(m)){
				Message dialog = new Message("Le mot-cle <" + mot + "> DEJA a été ajouté !!"); 
				dialog.setVisible(true);
			} else {
				ouvrage.ajouterMotCle(m);
				Message dialog = new Message("Le mot-cle <" + mot + "> a été ajouté"); 
				dialog.setVisible(true);
			}
		}
		
		public void nouvArticle(Parution parution, Article article) {
			if (article.getTitre().isEmpty()) 
			{
				Message dialog = new Message("Le titre ne peut pas être vide !");
				dialog.setVisible(true);
			}
			else if (article.getPage().isEmpty())
			{
				Message dialog = new Message("Vous n'avez pas indique la page !");
				dialog.setVisible(true);
			}
			else if (article.getAuteurs().isEmpty())
			{
				Message dialog = new Message("Vous devez ajouter au moins un auteur");
				dialog.setVisible(true);
			}
			else if (article.getMotCles().isEmpty())
			{
				Message dialog = new Message("Vous devez ajouter au moins un mot-cle");
				dialog.setVisible(true);
			}
			else
			{
				parution.ajoutArticle(article);
				
				//on ajoute l'article aux mot-clés
				HashSet<MotCle> m = article.getMotCles();
				for (MotCle m_ : m) {
					m_.ajoutDocument(article);
				}
				
				//on ajoute l'article aux auteurs
				Iterator<String> it = article.getAuteurs().keySet().iterator();

                while(it.hasNext())
                {
            		Auteur i = this.getAuteur(it.next().toString()); 
    				i.ajoutDocument(article); 
                }
                
                this.getVueSaisieParution().setEtat(Vue.finale);
				this.getVueSaisieParution().initArticle(parution);
				this.getVueSaisieParution().alimente(parution);
			}
		}
		
		public void fermerSaisieParution(Periodique pe, Parution pa, Article article) {
			if (pa!=null) { 
				Message f = new Message("");
				int val = JOptionPane.showConfirmDialog(f, "Etes-vous sûr de vouloir supprimer les modifications en cours ?", "Fermer", JOptionPane.YES_NO_OPTION);
				
				switch (val) {
					case 0: //oui
						pe.supprimerParution(pa); 
						pa.supprimer(); 
						pa = null;
						article = null;
						resetAuteur();
						this.fermerVue(this.getVueSaisieParution()); 
						break;
					case 1: break; //non
					default: break; //clic sur fermeture fenetre
				}
			}
			else this.fermerVue(this.getVueSaisieParution()); 
		}
		
/*auteurs*/
		public void ajouterOuvrageAuteur(Ouvrage ouvrage, Auteur a) {
			String key = a.getNom()+" "+a.getPrenom();
			ouvrage.ajouterAuteur(a, key);
			setAuteur(a);
		}
		
		public void ajouterArticleAuteur(Article article, Auteur a) {
			String key = a.getNom()+" "+a.getPrenom();
			article.ajouterAuteur(a, key);
			setAuteur(a);
		}
		
		public void setAuteur(Auteur a){
			String key = a.getNom()+" "+a.getPrenom();
			if(this._auteurs==null){
				Message dialog = new Message("CACAAAA!");
				dialog.setVisible(true);
			}
			else
				this._auteurs.put(key, a);
		}

		public Auteur rechAuteur(String nomAuteur, String prenomAuteur) {
			String key = nomAuteur+" "+prenomAuteur;
			return this.getAuteur(key);
		}

		public Auteur getAuteur(String key) {
			if(this._auteurs==null){
				Message dialog = new Message("Auteur vide !");
				dialog.setVisible(true);
				return(null);
			}
			else if (this._auteurs.isEmpty())
				return null;
			else{
				 return(this._auteurs.get(key));
			}
		}
		
} // Fin Classe contrôleur
